package pikasial.fs;

import java.util.ArrayList;
import javax.swing.event.TreeModelEvent;
import javax.swing.event.TreeModelListener;
import javax.swing.tree.TreeModel;
import javax.swing.tree.TreePath;

/**
 *
 * @author Nicolas
 */
public class PikasialTreeModel implements TreeModel {

    private ArrayList<TreeModelListener> treeModelListeners;
    private Dossier rootDossier;

    public PikasialTreeModel(Dossier d) {
        treeModelListeners = new ArrayList<TreeModelListener>();
        rootDossier = d;
    }

    /**
     * Retourne le dossier placé à la racine de ce modèle.
     * @return la racine du modèle
     */
    public Dossier getRoot() {
        return rootDossier;
    }

    /**
     * Retourne le fils situé à l'indice spécifié dans la collection des
     * fils de l'objet parent.
     * <p>
     * parent doit être un noeud obtenu depuis ce modèle. Ne devrait pas
     * retourner null si l'indice est correct.
     * @param parent - l'objet parent
     * @param index - l'indice du fils
     * @return le fils de parent, d'indice index
     */
    public Object getChild(Object parent, int index) {
        java.util.Iterator<Dossier> it =
            ((Dossier) parent).getSousDossiers().iterator();

        int indice = 0;
        while (it.hasNext()) {
            Dossier dFils = it.next();
            if (indice == index) {
                return dFils;
            }
            indice++;
        }
        return null;
    }

    /**
     * Retourne le nombre de fils du noeud spécifié.
     * <p>
     * parent est un noeud qui doit être obtenu depuis ce modèle.
     * @param parent - le noeud
     * @return le nombre de fils du noeud
     */
    public int getChildCount(Object parent) {
        return ((Dossier) parent).getSousDossiers().size();
    }

    /**
     * Teste si le noeud spécifié est une feuille.
     * @param arg0 - le noeud à tester
     * @return faux: pas de feuille dans ce modèle
     */
    public boolean isLeaf(Object arg0) {
        return false;
    }

    public void valueForPathChanged(TreePath path, Object newValue) {
        System.out.println("valueForPathChanged : "
                           + path + " --> " + newValue);
    }

    public int getIndexOfChild(Object parent, Object fiston) {
        if (parent == null || fiston == null) {
            return -1;
        }

        java.util.Iterator<Dossier> it =
            ((Dossier) parent).getSousDossiers().iterator();

        int i = 0;
        while (it.hasNext()) {
            if (it.next().equals((Dossier) fiston)) {
                return i;
            }
            i++;
        }
        return -1;
    }

    public void addTreeModelListener(TreeModelListener arg0) {
        treeModelListeners.add(arg0);
    }

    public void removeTreeModelListener(TreeModelListener arg0) {
        treeModelListeners.remove(treeModelListeners.indexOf(arg0));
    }

    /**
     * The only event raised by this model is TreeStructureChanged with the
     * root as path, i.e. the whole tree has changed.
     */
    protected void fireTreeStructureChanged(Dossier oldRoot) {
        //int len = treeModelListeners.size();
        TreeModelEvent e = new TreeModelEvent(this,
                                              new Object[] {oldRoot});
        for (TreeModelListener tml : treeModelListeners) {
            tml.treeStructureChanged(e);
        }
    }
    
    public void removeNodeFromParent(Dossier dossierParent, 
        Dossier dossierFils) {
        dossierParent.getSousDossiers().remove(dossierFils);
        fireTreeStructureChanged(getRoot());
    }
}
